Applying an abstract data structure description approach to parallelizing scientific pointer programs

Even though impressive progress has been made in the area of parallelizing scientific programs with arrays, the application of similar techniques to programs with pointer data structures has remained difficult. Unlike arrays which have a small number of well-defined properties that can be utilized by a parallelizing compiler, pointer data structures are used to implement a wide variety of structures that exhibit a much more diverse set of properties. The complexity and diversity of such properties means that, in general, scientific programs with pointer data structures cannot be effectively analyzed by an optimizing and parallelizing compiler.In order to provide a system in which the compiler can fully utilize the properties of different types of pointer data structures, we have developed a mechanism for the Abstract Description of Data Structures (ADDS). With our approach, the programmer can explicitly describe important properties such as dimensionality of the pointer data structure, independence of dimensions, and direction of traversal. These abstract descriptions of pointer data structures are then used by the compiler to guide analysis, optimization, and parallelization.In this paper we summarize the ADDS approach through the use of numerous examples of data structures used in scientific computations, we illustrate how such declarations are natural and non-tedious to specify, and we show how the ADDS declarations can be used to improve compile-time analysis. In order to demonstrate the viability of our approach, we show how such techniques can be used to parallelize an important class of scientific codes which naturally use recursive pointer data structures. In particular, we use our approach to develop the parallelization of an N-body simulation that is based on a relatively complicated pointer data structure, and we report the speedup results for a Sequent multiprocessor

Building, scaling, and sustaining a learning health system for surgical quality improvement: A toolkit

This article describes how to start, replicate, scale, and sustain a learning health system for quality improvement, based on the experience of the Michigan Surgical Quality Collaborative (MSQC). The key components to operationalize a successful collaborative improvement infrastructure and the features of a learning health system are explained. This information is designed to guide others who desire to implement quality improvement interventions across a regional network of hospitals using a collaborative approach. A toolkit is provided (under Supporting Information) with practical information for implementation.Peer Reviewedhttp://deepblue.lib.umich.edu/bitstream/2027.42/156156/3/lrh210215.pdfhttp://deepblue.lib.umich.edu/bitstream/2027.42/156156/2/lrh210215-sup-0001-supinfo.pdfhttp://deepblue.lib.umich.edu/bitstream/2027.42/156156/1/lrh210215_am.pd

The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to Assessing Empirical Evaluations

An unsound claim can misdirect a field, encouraging the pursuit of unworthy ideas and the abandonment of promising ideas. An inadequate description of a claim can make it difficult to reason about the claim, for example to determine whether the claim is sound. Many practitioners will acknowledge the threat of un- sound claims or inadequate descriptions of claims to their field. We believe that this situation is exacerbated and even encouraged by the lack of a systematic approach to exploring, exposing, and addressing the source of unsound claims and poor exposition. This paper proposes a framework that identifies three sins of reasoning that lead to unsound claims and two sins of exposition that lead to poorly described claims. Sins of exposition obfuscate the objective of determining whether or not a claim is sound, while sins of reasoning lead directly to unsound claims. Our framework provides practitioners with a principled way of critiquing the integrity of their own work and the work of others. We hope that this will help individuals conduct better science and encourage a cultural shift in our research community to identify and promulgate sound claims

Parallelizing Programs with Recursive Data Structures

Interference estimation is a useful tool in developing parallel programs and is a key aspect of automatically parallelizing sequential programs. Interference analysis and disambiguation mechanisms for programs with simple data types and arrays have become a standard part of parallelizing and vectorizing compilers. However, efficient and implementable techniques for interference analysis in the presence of dynamic data structures have yet to be developed. This thesis addresses the problem of estimating interference and parallelizing programs in the setting of an imperative language that supports dynamic data structures. By focusing on analysis methods for recursively defined pointer data structures such as trees and DAGs, we have developed efficient and implementable interference analysis tools and parallelization techniques. The interference analysis methods are based on estimating the relationships between accessible nodes in a data structure. We define a data abstraction for estimating relationships that leads to an efficient interference analysis. Analysis functions are provided for SIL, a simple imperative language that includes conditionals, loops and recursive procedures. The analysis is proven sound with respect to the standard semantics for SIL. Based on the interference analysis tools, a collection of parallelization techniques are developed and the coarse-grain techniques are used to develop a simple system for parallelizing programs for a shared memory machine. The analysis techniques and parallelization system have been implemented, and examples illustrating the methods are provided

Recursive Data Structures and Parallelism Detection

Interference estimation is a key aspect of automatic parallelization of programs. In this paper we study the problem of estimating interference in a language with dynamic data-structures. We focus on the case of binary trees to illustrate the approach. We develop a structural flow-analysis technique that allows us to estimate whether two statements influence disjoint sub-trees of a forest of dynamically-allocated binary trees. The method uses a regular-expression-like representation of the relationships between the nodes of the trees and is based on the algebraic properties of such expressions. We have implemented our analysis in Standard ML and have obtained some promising experimental results

Extended SSA Numbering: Introducing SSA Properties to Languages with Multi-level Pointers

Static Single Assignment (SSA) intermediate representations have become quite popular in compiler development. One advantage of the SSA form is that each use of a variable corresponds to exactly one definition, and thus two references of the same SSA variable must denote the same value. To date, most SSA forms concentrate on scalar variables, and it is difficult to extend these intermediate representations to languages with multi-level pointers like C. Translating a program into SSA form requires two steps. The first is inserting OE-nodes that join values from different flow of control paths, and the other renames variables such that each name has exactly one definition. When designing SSA forms to handle pointers, the insertion of OE-nodes is quite difficult. Thus, we propose a method that concentrates on the second step, in that we associate an SSA number to each variable reference, including references via pointers. Even without OE-nodes, we retain some of the properties of SSA suc..

Parallelizing programs with recursive data structures

In this paper, we present a novel method for parallelizing imperative programs in the presence of dynamic recursive data-structures. At the heart of parallelizing compilers are the dependence-analysis and disambiguation mechanisms. We present a three-pronged approach: (1) we augment an imperative language with easily parallelizable recursive data-structures, (2) we develop tools for disambugation and interference analysis for such structures, and (3) we present three methods for using information from the analysis to parallelize programs. We illustrate these techniques with a concrete example that has been processed by our system

Taming Control Flow: A Structured Approach to Eliminating Goto Statements

In designing optimizing and parallelizing compilers, it is often simpler and more efficient to deal with programs that have structured control flow. Although most programmers naturally program in a structured fashion, there remain many important programs and benchmarks that include some number of goto statements, thus rendering the entire program unstructured. Such unstructured programs cannot be handled with compilers built with analyses and transformations for structured programs. In this paper we present a straight-forward algorithm to structure C programs by eliminating all goto statements. The method works directly on a highlevel abstract syntax tree (AST) representation of the program and could easily be integrated into any compiler that uses an AST-based intermediate representation. The actual algorithm proceeds by eliminating each goto by first applying a sequence of gotomovement transformations followed by the appropriate goto-elimination transformation. We have implemented..